/**
 * 这个需要传入数组
 *控制人沿障碍物走，有自动绕行,能在平台上跳
 * 
 * 研究边界情况如何妥善的解决,ok 取数值的时候在一个函数里做
 * 
 * 用上下左右控制的时候是有自动绕行的，就是vx=0或vz=0,当vx!=0&vz!=0的时候是可以正常工作的
 */
 package kgame5.kgu.move {
import kgame5.k3d.core.obj3d.hardvo.HardVO;

public class XPosiM {
	
	//是否使用自动绕行,如果不使用自动绕行，则人撞墙了放到墙根即可
	public  var bUseAutoDetour:Boolean=true;
	
	//G放到这里不知道是否妥当
	public static const G : int = -3;

	//如果哟小人动画的话，则上下左右的动画的顺序
	public static const
		DIR_UP : int = 0,
		DIR_DOWN : int = 1,
		DIR_LEFT : int = 2,
		DIR_RIGHT : int = 3,
		
		DIR_NULL:int=99;//没有选择方向，注意要在128以内哦
	
	//根据方向取得角度
	public static function CalcAngle(dir:int):int{
		switch(dir){
			case DIR_UP:
			return 0;
			
			case DIR_DOWN:
			return 180;
			case DIR_LEFT:
			return 270;
			case DIR_RIGHT:
			return 90;
		}
		return 0;
	}
	//-------------------
	
	private static var instance:XPosiM;
	public static function getInstance():XPosiM{
		if(instance==null){
			instance=new XPosiM();
		}
		return instance;
	}
	/**
	 * 根据人物在地图的位置，根据地图障碍物信息，人物的方向和速度（方向为0就是无移动，因为方向为0）
	 *其实，贴地形走也是这么回事
	 *  @param role MovieClip2
	 * @param BGBarData byte[][] 地图障碍物数组，1不可以走，0可以走
	 * @param GRIDSIZE int
	 * 
	 * 返回的是自己是否绕行了，在联网的情况下，如果绕行了，需要通知其他坦克校正位置
	 * 
	 * 注意一个重要的前提是上一个位置是稳定位置？其实也不需要，坦克当前格子是障碍物也没关系，没和当前格子做碰撞
	 */
	 
	private var bDetoured:Boolean=false;
	public  function CalcPosi( md : HardVO, a2BarData : Array, CellSize : Number):Boolean {
  		
  		bDetoured=false;
		
		//Step 1,计算并设置高度
		/*
		md.floorAltitude=calcFloorAltitude(md.v3d_p.x,md.v3d_p.y,md.v3d_p.z,A,B,H,a2BarData,CellSize);
     
		//影子高度也在这里
		//md.getShadow().v3d_p.y=md.floorAltitude+1;
      
		// _root.tf_h.text=md.v3d_p.y+" "+ md.floorAltitude;
      
		if(md.v3d_p.y>md.floorAltitude){
		md.v3d_v.y+= G;
		md.v3d_p.y+= md.v3d_v.y;
    	 
		if(md.v3d_p.y<=md.floorAltitude){
		md.v3d_p.y=md.floorAltitude;
		md.v3d_v.y=0;
		T.p("到达目标");
		}
		}
		//*/
		var vx : Number = md.v3d_v.x;
		var vz : Number = md.v3d_v.z;
		
		if(vx == 0 && vz == 0) {
			return bDetoured;
		}
     
		//Step 1,尝试加到指定位置且计算并保存跟周围8个格子的碰撞情况
		HitTestAround(md, a2BarData, CellSize);
      
		//0,打上移动有效的标志
		md.bXok = true;
		md.bZok = true;
     
		//Step 2,分析具体情况设置bXok,bZok

		if(vx == 0 && vz != 0) {
			if(vz > 0) {
				if(b00 || b01 || b02) {
					//上面有一个撞上就不能走了
					md.bZok = false;
					autoDetourUP(md, a2BarData, CellSize);
				}else {
					//都没撞上就加
					md.v3d_p.z += md.v3d_v.z;
				}
			}else if(vz < 0) {
				if(b20 || b21 || b22) {
					//下面有一个撞上就不能走了
					md.bZok = false;
					autoDetourDOWN(md, a2BarData, CellSize);
				}else {
					//都没撞上就加
					md.v3d_p.z += md.v3d_v.z;
				}
			}
		}else if(vx != 0 && vz == 0) {
			if(vx > 0) {
				if(b02 || b12 || b22) {
					//右面有一个撞上就不能走了
					md.bXok = false;
					autoDetourRIGHT(md, a2BarData, CellSize);
				}else {
					//都没撞上就加
					md.v3d_p.x += md.v3d_v.x;
				}
			}else if(vx < 0) {
				if(b00 || b10 || b20) {
					//左面有一个撞上就不能走了
					md.bXok = false;
					autoDetourLEFT(md, a2BarData, CellSize);
				}else {
					//都没撞上就加
					md.v3d_p.x += md.v3d_v.x;
				}
			}
		}else if(vx != 0 && vz != 0) {//这个是比较复杂的斜着走的情况
			if(vx > 0) {
				if(vz > 0) {
					//----
					if(b02) {
						//有角

						if((b01 || b00) && b12 == false) {
							md.bZok = false;
						}else if(b01 == false && (b12 || b22)) {
							md.bXok = false;
						}else {
							//两边都有或两边都没有则不能动
							md.bZok = false;
							md.bXok = false;
						}
					}else {
						//无角
						if(b01 || b00) {
							md.bZok = false;
						}
						if(b12 || b22) {
							md.bXok = false;
						}
					}
     			//-----
				}else if(vz < 0) {
					//----
					if(b22) {
						//有角

						if((b21 || b20) && b12 == false) {
							md.bZok = false;
						}else if(b21 == false && (b12 || b02)) {
							md.bXok = false;
						}else {
							//两边都有或两边都没有则不能动
							md.bZok = false;
							md.bXok = false;
						}
					}else {
						//无角
						if(b21 || b20) {
							md.bZok = false;
						}
						if(b12 || b02) {
							md.bXok = false;
						}
					}
     			//-----
				}
			}else if(vx < 0) {
				if(vz > 0) {
					//----
					if(b00) {
						//有角

						if((b01 || b02) && b10 == false) {
							md.bZok = false;
						}else if(b01 == false && (b10 || b20)) {
							md.bXok = false;
						}else {
							//两边都有或两边都没有则不能动
							md.bZok = false;
							md.bXok = false;
						}
					}else {
						//无角
						if(b01 || b02) {
							md.bZok = false;
						}
						if(b10 || b20) {
							md.bXok = false;
						}
					}
     			//-----
				}else if(vz < 0) {
					//----
					if(b20) {
						//有角

						if((b21 || b22) && b10 == false) {
							md.bZok = false;
						}else if(b21 == false && (b10 || b00)) {
							md.bXok = false;
						}else {
							//两边都有或两边都没有则不能动
							md.bZok = false;
							md.bXok = false;
						}
					}else {
						//无角
						if(b21 || b22) {
							md.bZok = false;
						}
						if(b10 || b00) {
							md.bXok = false;
						}
					}
     			//-----
				}
			}
     	
			//----真正加上,这里是处理的是斜向运动的情况
			//Step 3 如果不能放到指定位置，则返回 
			if(md.bXok) {
				md.v3d_p.x += md.v3d_v.x;
			}
			if(md.bZok) {
				md.v3d_p.z += md.v3d_v.z;
			}
		}
		
		return bDetoured;
	}

	
	
	//！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
	//自动绕行的时候用来检测碰撞用的
	//注意barHeight其实应该是barType,0无，1坑，2配额破坏，3不可破坏
	public  static function hitTest(x : Number,y : Number,z : Number,A : Number,B : Number,H : Number,
		a2BarData : Array,CellSize : Number,r : int,c : int) : Boolean {
		
		//getBarData()里包含了数组越界的处理，当数组越界的时候，它认为是障碍物
		var barHeight : Number = getBarData(a2BarData, r, c);
		//a2BarData[r][c];

		if(barHeight == 0) {
			//此格子高度是0的可以马上返回了就
			return false;
		}
		
		//高度的格子
		var h : Number = Math.floor(y / CellSize);//0,1,2,3

		var blockX : Number = calcX(c, CellSize);
		var blockZ : Number = calcZ(r, CellSize);
		
		var dx : Number = x - blockX;
		var dz : Number = z - blockZ;
		if(Math.abs(dx) < (A + CellSize) / 2 && Math.abs(dz) < (B + CellSize) / 2) {
			if(barHeight >= (h + 1)) {
				return true;
			}
		}
		return false;
	}

	//检测自己底下的9个格子，这个是用来判断是否可以下落用的
	public  function hitTest9(x : Number,y : Number,z : Number,A : Number,B : Number,H : Number,
		a2BarData : Array,CellSize : Number) : Boolean {
		var c : Number = calcCol(x, CellSize);
		var r : Number = calcRow(z, CellSize);
		if(hitTest(x, y, z, A, B, H, a2BarData, CellSize, r, c)
			 || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r - 1, c) 
			 || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r + 1, c) 
			 || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r, c - 1) 
			 || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r, c + 1)
			  || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r - 1, c - 1) 
			  || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r + 1, c + 1)
			   || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r - 1, c + 1) 
			   || hitTest(x, y, z, A, B, H, a2BarData, CellSize, r + 1, c - 1)
			) {
			return true;
		}
		return false;
	}

	//计算一个位置的底部的高度
	public  function calcFloorAltitude(x : Number,y : Number,z : Number,A : Number,B : Number,H : Number,
		a2BarData : Array,CellSize : Number) : Number {
		while(y > 0) {
			y -= CellSize;
			if(y < 0) {
				return 0;
			}
			if(hitTest9(x, y, z, A, B, H, a2BarData, CellSize)) {
				var t : Number = (Math.floor(y / CellSize) + 1) * CellSize;
					
				//T.p("下面有东西 y:"+y+" t:"+t);

				return t;
			}
		}
		return 0;
	}

	public  static function calcX(col : int,CellSize : Number) : Number {
		return col * CellSize + CellSize / 2;
	}

	public static function calcZ(row : int,CellSize : Number) : Number {
		return -(row * CellSize + CellSize / 2);
	}

	public  static function calcCol(x : Number,CellSize : Number) : int {
		return Math.floor(x / CellSize);
	}

	public static function calcRow(z : Number,CellSize : Number) : int {
		return Math.floor(-z / CellSize);
	}

	//************************尝试加到指定位置并周围的8个格子做碰撞检测***************************
	//,这个完全都能独立拿出来,结果保存在b00,b01...中，用这个而不用数组是为了节省运算
	public  var
		b00 : Boolean = false,b01 : Boolean = false,b02 : Boolean = false,
		b10 : Boolean = false,b12 : Boolean = false,
		b20 : Boolean = false,b21 : Boolean = false,b22 : Boolean = false;

	public  function HitTestAround(md : HardVO,a2BarData : Array,CellSize : Number) {
		//0，准备
		var A : Number = md.aabb.A;
		var B : Number = md.aabb.B;
		var H : Number = md.aabb.H;
		 
		//计下自己当前的c,r
		var origCol : int = calcCol(md.v3d_p.x, CellSize);
		var origRow : int = calcRow(md.v3d_p.z, CellSize);
     
		//记下加到指定位置后的坐标
		var x : Number = md.v3d_p.x + md.v3d_v.x;
		var y : Number = md.v3d_p.y;
		//y不用动，需要做的是在这个碰撞检测之前就把Y设置成稳定位置即可
		var z : Number = md.v3d_p.z + md.v3d_v.z;
     
		//2,记录跟周围8个格子碰撞的结果
		b00 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow - 1, origCol - 1);
		b01 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow - 1, origCol);
		b02 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow - 1, origCol + 1);
       
		b10 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow, origCol - 1);
		// var b11:Boolean=hitTest(x,y,z,A,B,H,a2BarData[r][c],CellSize,r,c);
		b12 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow, origCol + 1);
        
		b20 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow + 1, origCol - 1);
		b21 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow + 1, origCol);
		b22 = hitTest(x, y, z, A, B, H, a2BarData, CellSize, origRow + 1, origCol + 1);
	}

	//************************自动绕行****************************
	//在上方被阻挡的情况下自动绕行 origX是因为这里是尝试加到指定位置后的md.v3d_p,所以要用原始位置
	//这个执行的前提是b00,b01,b02有一个是撞上的且vx=0
	private  function autoDetourUP(md : HardVO,
					a2BarData : Array,CellSize : Number) {
		//标志说自己绕行了
		bDetoured=true;
		
		//
		var A : Number = md.aabb.A;
		var B : Number = md.aabb.B;
		var H : Number = md.aabb.H;
	
		//1,把z放到目标位置,如果不在墙根则先移动到墙根
		var MY_Z : Number = calcZ(calcRow(md.v3d_p.z, CellSize) - 1, CellSize) - CellSize / 2 - B / 2;
		if(md.v3d_p.z != MY_Z) {
			md.v3d_p.z = MY_Z;
			//return;
		}
		
		if(bUseAutoDetour==false){//如果不使用自动绕行，则放到墙根就返回
			return;
		}
		
		//2,z到达墙根，则开始执行绕行
		var x : Number = md.v3d_p.x;
		var z : Number = md.v3d_p.z;
		
		var vx : Number = md.v3d_v.x;
		var vz : Number = md.v3d_v.z;
		
		//绕行的时候的x速度其实是vz
		var xspeed : Number = Math.abs(vz);
		//z轴的速度为默认的速度
		
		//计下自己当前的c,r
		var origCol : int = calcCol(md.v3d_p.x, CellSize);
		var origRow : int = calcRow(md.v3d_p.z, CellSize);
		
		//计算周围8个格子是否是障碍
		var b00 : Boolean = getBarData(a2BarData, origRow - 1, origCol - 1) == 0 ? false : true;
		var b01 : Boolean = getBarData(a2BarData, origRow - 1, origCol) == 0 ? false : true;
		var b02 : Boolean = getBarData(a2BarData, origRow - 1, origCol + 1) == 0 ? false : true;
		var b10 : Boolean = getBarData(a2BarData, origRow, origCol - 1) == 0 ? false : true;
		var b12 : Boolean = getBarData(a2BarData, origRow, origCol + 1) == 0 ? false : true;
		var b20 : Boolean = getBarData(a2BarData, origRow + 1, origCol - 1) == 0 ? false : true;
		var b21 : Boolean = getBarData(a2BarData, origRow + 1, origCol) == 0 ? false : true;
		var b22 : Boolean = getBarData(a2BarData, origRow + 1, origCol + 1) == 0 ? false : true;
		
		//计算左右临界位置
		var LB : Number = calcX(origCol, CellSize) - CellSize / 2 + A / 2;
		var RB : Number = calcX(origCol, CellSize) + CellSize / 2 - A / 2;
		
		if(b01) {//中间格子不为空
			if(x <= LB) {
				//是向左运动
				if(b00 == false && b10 == false) {
					//左边可行
					md.v3d_p.x -= xspeed;
				}
			}else if(x >= RB) {
				//是向左运动
				if(b02 == false && b12 == false) {
					//右边可行
					md.v3d_p.x += xspeed;
				}
			}else{//这个时候表示推动一个东西
				//T.p();
			}
		}else {//中间格子为空
			if(x <= LB) {
				//是向左运动
				if(b00) {
					//可向右走
					md.v3d_p.x += xspeed;
				}
			}else if(x >= RB) {
				//是向左运动
				if(b02) {
					//可向左走
					md.v3d_p.x -= xspeed;
				}
			}
		}
	}

	private  function autoDetourDOWN(md : HardVO,
					a2BarData : Array,CellSize : Number
					) {
		//标志说自己绕行了
		bDetoured=true;
		
		//
		var A : Number = md.aabb.A;
		var B : Number = md.aabb.B;
		var H : Number = md.aabb.H;
	
		//1,把z放到目标位置,如果不在墙根则先移动到墙根
		var MY_Z : Number = calcZ(calcRow(md.v3d_p.z, CellSize) + 1, CellSize) + CellSize / 2 + B / 2;
		if(md.v3d_p.z != MY_Z) {
			md.v3d_p.z = MY_Z;
			//return;
		}
		
		if(bUseAutoDetour==false){//如果不适用自动绕行，则放到墙根就返回
			return;
		}
		
		//2,z到达墙根，则开始执行绕行
		var x : Number = md.v3d_p.x;
		var z : Number = md.v3d_p.z;
		
		var vx : Number = md.v3d_v.x;
		var vz : Number = md.v3d_v.z;
		
		//绕行的时候的x速度其实是vz
		var xspeed : Number = Math.abs(vz);
		//z轴的速度为默认的速度
		
		//计下自己当前的c,r
		var origCol : int = calcCol(md.v3d_p.x, CellSize);
		var origRow : int = calcRow(md.v3d_p.z, CellSize);
		
		//计算周围8个格子是否是障碍
		var b00 : Boolean = getBarData(a2BarData, origRow - 1, origCol - 1) == 0 ? false : true;
		var b01 : Boolean = getBarData(a2BarData, origRow - 1, origCol) == 0 ? false : true;
		var b02 : Boolean = getBarData(a2BarData, origRow - 1, origCol + 1) == 0 ? false : true;
		var b10 : Boolean = getBarData(a2BarData, origRow, origCol - 1) == 0 ? false : true;
		var b12 : Boolean = getBarData(a2BarData, origRow, origCol + 1) == 0 ? false : true;
		var b20 : Boolean = getBarData(a2BarData, origRow + 1, origCol - 1) == 0 ? false : true;
		var b21 : Boolean = getBarData(a2BarData, origRow + 1, origCol) == 0 ? false : true;
		var b22 : Boolean = getBarData(a2BarData, origRow + 1, origCol + 1) == 0 ? false : true;
		
		//计算左右临界位置
		var LB : Number = calcX(origCol, CellSize) - CellSize / 2 + A / 2;
		var RB : Number = calcX(origCol, CellSize) + CellSize / 2 - A / 2;
		
		if(b21) {
			if(x <= LB) {
				//是向左运动
				if(b20 == false && b10 == false) {
					//左边可行
					md.v3d_p.x -= xspeed;
				}
			}else if(x >= RB) {
				//是向左运动
				if(b22 == false && b12 == false) {
					//右边可行
					md.v3d_p.x += xspeed;
				}
			}
		}else {
			//中间为空
			if(x <= LB) {
				//是向左运动
				if(b20) {
					//可向右走
					md.v3d_p.x += xspeed;
				}
			}else if(x >= RB) {
				//是向左运动
				if(b22) {
					//可向左走	
					md.v3d_p.x -= xspeed;
				}
			}
		}
	}

	private  function autoDetourRIGHT(md : HardVO,
					a2BarData : Array,CellSize : Number
					) {
		//标志说自己绕行了
		bDetoured=true;
		
		//
		var A : Number = md.aabb.A;
		var B : Number = md.aabb.B;
		var H : Number = md.aabb.H;
	
		//1,把x放到目标位置,如果不在墙根则先移动到墙根
		var MY_X : Number = calcX(calcCol(md.v3d_p.x, CellSize) + 1, CellSize) - CellSize / 2 - A / 2;
		if(md.v3d_p.x != MY_X) {
			md.v3d_p.x = MY_X;
			//return;
		}
		
		if(bUseAutoDetour==false){//如果不适用自动绕行，则放到墙根就返回
			return;
		}
		
		//2,x到达墙根，则开始执行绕行
		var x : Number = md.v3d_p.x;
		var z : Number = md.v3d_p.z;
		
		var vx : Number = md.v3d_v.x;
		var vz : Number = md.v3d_v.z;
		
		//绕行的时候的z速度其实是vx
		var zspeed : Number = Math.abs(vx);
		//x轴的速度为默认的速度
		
		//计下自己当前的c,r
		var origCol : int = calcCol(md.v3d_p.x, CellSize);
		var origRow : int = calcRow(md.v3d_p.z, CellSize);
		//计算周围8个格子是否是障碍
		var b00 : Boolean = getBarData(a2BarData, origRow - 1, origCol - 1) == 0 ? false : true;
		var b01 : Boolean = getBarData(a2BarData, origRow - 1, origCol) == 0 ? false : true;
		var b02 : Boolean = getBarData(a2BarData, origRow - 1, origCol + 1) == 0 ? false : true;
		var b10 : Boolean = getBarData(a2BarData, origRow, origCol - 1) == 0 ? false : true;
		var b12 : Boolean = getBarData(a2BarData, origRow, origCol + 1) == 0 ? false : true;
		var b20 : Boolean = getBarData(a2BarData, origRow + 1, origCol - 1) == 0 ? false : true;
		var b21 : Boolean = getBarData(a2BarData, origRow + 1, origCol) == 0 ? false : true;
		var b22 : Boolean = getBarData(a2BarData, origRow + 1, origCol + 1) == 0 ? false : true;
		
		
		//计算左右临界位置
		var UB : Number = calcZ(origRow, CellSize) + CellSize / 2 - B / 2;
		var DB : Number = calcZ(origRow, CellSize) - CellSize / 2 + B / 2;
		
		if(b12) {
			
			if(z >= UB) {
				//是向上运动
				if(b02 == false && b01 == false) {
					//上边可行
					md.v3d_p.z += zspeed;
				}
			}else if(z <= DB) {
				//是向下运动
				if(b22 == false && b21 == false) {
					//下边可行
					md.v3d_p.z -= zspeed;
				}
			}
		}else {
			//中间为空

			if(z >= UB) {
				//是向下运动
				if(b02) {
					//可向下走
					md.v3d_p.z -= zspeed;
				}
			}else if(z <= DB) {
				//是向左运动
				if(b22) {
					//可向上走
					md.v3d_p.z += zspeed;
				}
			}
		}
	}

	private  function autoDetourLEFT(md : HardVO,
					a2BarData : Array,CellSize : Number
					) {
		
		//标志说自己绕行了
		bDetoured=true;
		
		//
		var A : Number = md.aabb.A;
		var B : Number = md.aabb.B;
		var H : Number = md.aabb.H;
	
		//1,把x放到目标位置,如果不在墙根则先移动到墙根
		var MY_X : Number = calcX(calcCol(md.v3d_p.x, CellSize) - 1, CellSize) + CellSize / 2 + A / 2;
		if(md.v3d_p.x != MY_X) {
			md.v3d_p.x = MY_X;
			//return;
		}
		
		if(bUseAutoDetour==false){//如果不适用自动绕行，则放到墙根就返回
			return;
		}
		
		//2,x到达墙根，则开始执行绕行
		var x : Number = md.v3d_p.x;
		var z : Number = md.v3d_p.z;
		
		var vx : Number = md.v3d_v.x;
		var vz : Number = md.v3d_v.z;
		
		//绕行的时候的z速度其实是vx
		var zspeed : Number = Math.abs(vx);
		//x轴的速度为默认的速度
		
		//计下自己当前的c,r
		var origCol : int = calcCol(md.v3d_p.x, CellSize);
		var origRow : int = calcRow(md.v3d_p.z, CellSize);
		//计算周围8个格子是否是障碍
		var b00 : Boolean = getBarData(a2BarData, origRow - 1, origCol - 1) == 0 ? false : true;
		var b01 : Boolean = getBarData(a2BarData, origRow - 1, origCol) == 0 ? false : true;
		var b02 : Boolean = getBarData(a2BarData, origRow - 1, origCol + 1) == 0 ? false : true;
		var b10 : Boolean = getBarData(a2BarData, origRow, origCol - 1) == 0 ? false : true;
		var b12 : Boolean = getBarData(a2BarData, origRow, origCol + 1) == 0 ? false : true;
		var b20 : Boolean = getBarData(a2BarData, origRow + 1, origCol - 1) == 0 ? false : true;
		var b21 : Boolean = getBarData(a2BarData, origRow + 1, origCol) == 0 ? false : true;
		var b22 : Boolean = getBarData(a2BarData, origRow + 1, origCol + 1) == 0 ? false : true;
		
		
		//计算左右临界位置
		var UB : Number = calcZ(origRow, CellSize) + CellSize / 2 - B / 2;
		var DB : Number = calcZ(origRow, CellSize) - CellSize / 2 + B / 2;
		if(b10) {
			
			if(z >= UB) {
				//是向上运动
				if(b00 == false && b01 == false) {
					//上边可行
					md.v3d_p.z += zspeed;
				}
			}else if(z <= DB) {
				//是向下运动
				if(b20 == false && b21 == false) {
					//下边可行
					md.v3d_p.z -= zspeed;
				}
			}
		}else {
			//中间为空

			if(z >= UB) {
				//是向下运动
				if(b00) {
					//可向下走
					md.v3d_p.z -= zspeed;
				}
			}else if(z <= DB) {
				//是向左运动
				if(b20) {
					//可向上走
					md.v3d_p.z += zspeed;
				}
			}
		}
	}

	//取得地图里的一个格子的数据
	public  static function getBarData(a2BarData : Array,r : int,c : int) : int {
		//边界之外不能走
		if(r < 0 
			|| r > a2BarData.length - 1 
			|| c < 0 
			|| c > a2BarData[0].length - 1) {
			return 1;// 表示有障碍
		}
		
		return a2BarData[r][c];
	}

	//这个是控制一个简单的落地,返回的是否落地了
	public  function Falling(md : HardVO,G : int = -3,GroundY : int = 0) : Boolean {
		md.v3d_v.y += G;
		md.v3d_p.y += md.v3d_v.y;
		if(md.v3d_p.y <= GroundY) {
			md.v3d_p.y = GroundY;
			return true;
		}
		return false;
	}
	
	
}//end of Class 
}